home *** CD-ROM | disk | FTP | other *** search
/ Aminet 41 / Aminet 41 (2001)(Schatztruhe)[!][Feb 2001].iso / Aminet / dev / c / GSys.lha / gsys / gsystem / GFile.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-18  |  3.5 KB  |  211 lines
  1.  
  2. /* Author Anders Kjeldsen */
  3.  
  4. #ifndef GFILE_CPP
  5. #define GFILE_CPP
  6.  
  7. #include "gsystem/GFile.h"
  8. #include "gsystem/GObject.cpp"
  9.  
  10. GFile::GFile(GSTRPTR filename)
  11. {
  12.     memset((void *)this, 0, sizeof (class GFile) );
  13.  
  14.     if ( InitGObject("GFile") )
  15.     {
  16.         if (! FileOpen(filename) )
  17.         {
  18.             AddError("GFile", "Open() failed");
  19.         }
  20.     }
  21. }
  22.  
  23. GFile::~GFile()
  24. {
  25.     FileClose();
  26. }
  27.  
  28. BOOL GFile::FileOpen(GSTRPTR filename)
  29. {
  30.     if (FH) FileClose();
  31.  
  32. #ifdef GWINDOWS
  33.     DWORD FileSizeHigh = 0;
  34. #endif
  35.  
  36.     if (filename)
  37.     {
  38. #ifdef GAMIGA
  39.         FH = Open(filename, MODE_READWRITE);
  40.         if ( FH )
  41.         {
  42.             Seek(FH, 0, OFFSET_END);
  43.             FileSize = Seek(FH, 0, OFFSET_BEGINNING);
  44.             if ( strlen(filename) > 255 )
  45.             {
  46.                 Close(FH);
  47.                 FH = NULL;
  48.                 return FALSE;
  49.             }
  50.             else
  51.             {
  52.                 strcpy(FileName, filename);
  53.                 return TRUE;
  54.             }
  55.         }
  56. #endif
  57.  
  58. #ifdef GWINDOWS
  59.         if ( FH = CreateFile( filename, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, NULL, NULL) )
  60.         {
  61.             FileSize = GetFileSize(FH, &FileSizeHigh);
  62.             if (strlen(filename) > 255)
  63.             {
  64.                 CloseHandle(FH);
  65.                 return FALSE;
  66.             }
  67.             else 
  68.             {
  69.                 strcpy(FileName, filename);
  70.                 return TRUE;
  71.             }
  72.         }
  73. #endif
  74.  
  75.     }
  76.     return FALSE;
  77. }
  78.  
  79. BOOL GFile::FileClose()
  80. {
  81.     if (FH)
  82.     {
  83. #ifdef GAMIGA
  84.         Close(FH);
  85. #endif
  86. #ifdef GWINDOWS
  87.         CloseHandle(FH);
  88. #endif
  89.         FH = NULL;
  90.         *FileName = 0;
  91.         return TRUE;
  92.     }
  93.     return FALSE;
  94. }
  95.  
  96. BOOL GFile::FileLock() 
  97. { 
  98.     return FALSE;
  99. } 
  100.  
  101. BOOL GFile::FileUnLock() 
  102. { 
  103.     return TRUE;
  104. } 
  105.  
  106. BOOL GFile::FileSeek(GWORD offset, GUWORD seekmode)
  107. {
  108.     if (*FileName && FH)
  109.     {
  110.         GWORD temp = FilePtr;
  111.         if ( seekmode == GSEEK_START ) temp = 0;
  112.         else if ( seekmode == GSEEK_END ) temp = FileSize;
  113.  
  114.         temp += offset;
  115. #ifdef GAMIGA
  116.         if ( Seek(FH, temp, OFFSET_BEGINNING) != -1 )
  117. #endif
  118. #ifdef GWINDOWS
  119.         if ( SetFilePointer(FH, temp, NULL, FILE_BEGIN) != -1 )
  120. #endif
  121.         {
  122.             FilePtr = temp;
  123. //            WriteLog("Seek ok\n");
  124.             return TRUE;
  125.         }
  126.     }
  127.     return FALSE;
  128. }
  129.  
  130. BOOL GFile::FileRead(GAPTR buffer, GUWORD len)
  131. {
  132. #ifdef GWINDOWS
  133.     DWORD FileSizeHigh = 0;
  134. #endif
  135.     GWORD delta;
  136.     if (FH && buffer)
  137.     {
  138.         if (FileSize >= FilePtr)
  139.         {
  140.             delta = FileSize-(FilePtr+len);
  141.             if (delta < 0)
  142.             {
  143.                 len+= delta;
  144.             }
  145. #ifdef GAMIGA
  146.             Seek(FH, FilePtr, OFFSET_BEGINNING);
  147.             if ( Read(FH, buffer, len) )
  148.             {
  149.                 Seek(FH, FilePtr, OFFSET_BEGINNING);
  150.                 return TRUE;
  151.             }
  152.             else AddError("ReadError", "Read Failed");
  153. #endif
  154.  
  155. #ifdef GWINDOWS
  156.             SetFilePointer(FH, FilePtr, 0, FILE_BEGIN);
  157.             if ( ReadFile(FH, buffer, len, &FileSizeHigh, 0) )
  158.             {
  159.                 SetFilePointer(FH, FilePtr, 0, FILE_BEGIN);
  160.                 return TRUE;
  161.             }
  162. #endif
  163.         }
  164.         else AddError("WriteError", "FilePtr too big");
  165.     }
  166.     else AddError("WriteError", "No File");
  167.     Seek(FH, FilePtr, OFFSET_BEGINNING);
  168.     return FALSE;
  169. }
  170.  
  171. BOOL GFile::FileWrite(GAPTR buffer, GUWORD len)
  172. {
  173. #ifdef GWINDOWS
  174.     DWORD FileSizeHigh = 0;
  175. #endif
  176.  
  177.     if (FH && buffer)
  178.     {
  179.         if (FileSize >= FilePtr)
  180.         {
  181. #ifdef GAMIGA
  182.             Seek(FH, FilePtr, OFFSET_BEGINNING);
  183.             if ( Write(FH, buffer, len) )
  184.             {
  185.                 Seek(FH, 0, OFFSET_END);
  186.                 FileSize = Seek(FH, FilePtr, OFFSET_BEGINNING);
  187.                 return TRUE;
  188.             }
  189.             else AddError("WriteError", "Write Failed");
  190. #endif
  191.  
  192. #ifdef GWINDOWS
  193.             SetFilePointer(FH, FilePtr, 0, FILE_BEGIN);
  194.             if ( WriteFile(FH, buffer, len, &FileSizeHigh, 0) )
  195.             {
  196.                 SetFilePointer(FH, FilePtr, 0, FILE_BEGIN);
  197.                 FileSize = GetFileSize(FH, &FileSizeHigh);
  198.                 return TRUE;
  199.             }
  200. #endif
  201.         }
  202.         else AddError("WriteError", "FilePtr too big");
  203.     }
  204.     else AddError("WriteError", "No File");
  205.     Seek(FH, FilePtr, OFFSET_BEGINNING);
  206.     return FALSE;
  207. }
  208.  
  209. #endif /* GFILE_CPP */
  210.  
  211.